package unipd.esp1112.pro;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.ContentValues;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;


/**
 * the application main activity, here the user wait for the GPS signal to be acquired and starts his training activity, then is
 * notified when each limit he has previously set up is reached. The activity starts a service where the recording
 * actually takes place, get updated data from it, displays them to the user and when each previously set up limit is reached
 * in the training it updates the service with the next limit in the list . Then when the last limit is reached or the user 
 * wants to stop the recording of his training the collected data are saved to the application database. 
 * 
 * @author andrea basso, federico lancerin, alex tomasello
 * 
 */
public class MisurazioniSuMisura extends Activity {

	/**
	 * variable to store the name of the profile the user is currently using.
	 */
	private String nome;
	/**
	 * an array of strings passed from the previous activity that contains the series of kind of limit the user want to reach.
	 */
	private String[] attivitaImpostate;
	/**
	 * an array of int passed from the previous activity that contains the series of actual numerical limits to reach.
	 */
	private String[] limitiImpostati;
	/**
	 * int representing the couple of training activity - limit currently being recorded.
	 */
	private int numeroAttivita = 0;	
	/**
	 * the name of the kind of training activity that brought the user here.
	 */
	private final String tipoAttivita = "su misura";
	/**
	 * variable used to retrieve an instance of the application private database.
	 */
	private MyOpenHelper op;
	/**
	 * variable used to reference the database.
	 */
	private SQLiteDatabase db;
	/**
	 * intent used to start the recording process of the service.
	 */
	private Intent intentServizi;
	/**
	 * an instance of the system calendar.
	 */
	final Calendar c = Calendar.getInstance();
	/**
	 * Date when the recording process has started.
	 */
	private Date inizioAttivita;
	/**
	 * user data to pass to the service for calories counting.
	 */	
	private boolean isMale; 	// sex
	private int altezza; 		// height
	private int peso; 			// weight
	private int anni; 			// age	
	/**
	 * instance of Servizi, the service running and recording data.
	 */
	private Servizi cronoGpsService;
	/**
	 * boolean representing the state of the connection between activity and service.
	 */
	private boolean isBound = false;
	/**
	 * boolean representing if the system GPS service is capable of supplying the number of satellites used for
	 * each location update.
	 */
	private boolean hasNumSatellites;	
	/**
	 * int that represent the step of the recording process so that tasks can behave differently according to the state of this variable
	 * "step" that will assume just these possible values : PREPARAZIONE, PRONTO, REGISTRAZIONE, FINE.
	 */
	private int step = 0;
	private final int PREPARAZIONE = 0;
	private final int PRONTO = 1;
	private final int REGISTRAZIONE = 2;
	private final int FINE = 3;
	/**
	 * timer used to schedule different tasks at different stages of the recording process.
	 */
	private Timer timer;
	/**
	 * button used to start and stop the training session and going beck to main menu.
	 */
	private Button startStop;	
	/**
	 * a Parziale variable ( inner class defined at the end of this document ), created at the beginning of the recording
	 * and then every time a limit is reached. 
	 */
	private Parziale parziale;
	/**
	 * an int containing the updated portion of the current training activity.
	 */
	private int parzialeLimite;
	/**
	 * String to be displayed representing the partial progress of the current training activity.
	 */
	private String limiteAggiornato;
	/**
	 * textview updated with "limiteAggiornato" every second.
	 */
	private TextView daAggiornare;
	/**
	 * progressbar representing the partial progress of the current training activity.
	 */
	private ProgressBar avanzamentoParziale;
	/**
	 * layout where to insert the next training activity once a limit has been reached.
	 */
	private LinearLayout cassettoAttivita;
	/**
	 * layout where to insert the textview "daAggiornare".
	 */
	private LinearLayout cassettoLimiti;	
	/**
	 * when a limit is reached this string is updated with the next training activity and passed to the service.
	 */
	private String attivitaDaPassareAServizio;
	/**
	 * when a limit is reached this int is updated with the next training limit and passed to the service.
	 */
	private int limiteDaPassareAServizio;
	/**
	 * boolean value, true if the alertdialog that asks the user to enable GPS provider has already been displayed.
	 */	
	private boolean alreadyAskedToUser;
	/**
	 * semaphore used to one-start the next timertask in a timertask sequence.
	 */
	private boolean checkPrePlayAlreadyStarted;
	/**
	 * semaphore used to one-start the next timertask in a timertask sequence.
	 */
	private boolean updateDataFromServiceAlreadyStarted;
	/**
	 * VARIABLES updated with fresh values taken from the service every second.
	 */
	private String datoDistanza;		// distance
	private String datoCronometro;		// clock
	private String datoCalorie;			// calories
	private String datoVelocita;		// medium speed
	private String datoVelocitaIst;		// instant speed
	private String datoAltitudine;		// altitude
	private String datoSatelliti;		// # of satellites used for last fix	
	/**
	 * TEXTVIEWS updated with updated recording data every second.
	 */
	private TextView velocitaist;			// instant speed
	private TextView altitudine;			// altitude
	private TextView satelliti;				// # of satellites used for last fix
	/**
	 * semaphore used to prevent an automated save to DB after a manual prompted one.
	 */
	private boolean alreadySavedDb = false;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.misurazionisumisura);

		cassettoAttivita = (LinearLayout) findViewById(R.id.scrollActivitySuMisura);
		cassettoLimiti = (LinearLayout) findViewById(R.id.scrollLimitSuMisura);
		velocitaist = (TextView) findViewById(R.id.velocitaistantsumisura);
		altitudine = (TextView) findViewById(R.id.altitudinesumisura);
		satelliti = (TextView) findViewById(R.id.satellitisumisura);
		startStop = (Button) findViewById(R.id.startStopSuMisura);
		avanzamentoParziale = (ProgressBar) findViewById(R.id.progressbarsumisura);

		step = PREPARAZIONE;

		datoCronometro = "0:00:00";
		datoDistanza = "0 m";
		datoCalorie = "0 kcal";
		datoVelocita = "0 km/h";
		datoVelocitaIst = "0 m/s";
		datoAltitudine = "0 m slm";
		datoSatelliti = "0";
		inizioAttivita = null;

		hasNumSatellites = false;
		alreadyAskedToUser = false;
		checkPrePlayAlreadyStarted = false;
		updateDataFromServiceAlreadyStarted = false;

		// creo l'intent che mi servirà a far partire l'aggiornamento del
		// Servizio
		intentServizi = new Intent(this, Servizi.class);

		// ricevo il nome utente dall'intent con cui è stata lanciata
		// l'activity
		Intent intent = getIntent();
		nome = intent.getStringExtra("profilo");
		attivitaImpostate = intent.getStringArrayExtra("attivita");
		limitiImpostati = intent.getStringArrayExtra("valori");

		parziale = new Parziale(step);

		attivitaDaPassareAServizio = attivitaImpostate[0];
		limiteDaPassareAServizio = Integer.parseInt(limitiImpostati[0]);

		TextView inizializzaAttivita = new TextView(this);
		TextView inizializzaLimiti = new TextView(this);
		inizializzaAttivita.setText(attivitaImpostate[0]);
		limiteAggiornato = "0 / " + limitiImpostati[0] + " ";

		if (attivitaImpostate[0].equalsIgnoreCase("distanza"))
			limiteAggiornato += "m";
		else if (attivitaImpostate[0].equalsIgnoreCase("calorie"))
			limiteAggiornato += "kcal";
		else
			limiteAggiornato += "min";

		inizializzaLimiti.setText(limiteAggiornato);
		cassettoAttivita.addView(inizializzaAttivita);
		cassettoLimiti.addView(inizializzaLimiti);
		// apro database e raccolgo dati profilo da passare al servizio
		op = new MyOpenHelper(this);
		db = op.getReadableDatabase();
		Cursor query = db.rawQuery("SELECT * FROM " + op.TABLE1 + " where " + op.NOME + "='" + nome + "'", null);
		query.moveToNext();

		// estraggo i dati utente che mi servono dalla query
		altezza = Integer.parseInt(query.getString(3));
		peso = Integer.parseInt(query.getString(4));
		if (query.getString(1).equals("1"))
			isMale = true;
		else
			isMale = false;
		String[] dataSplit = query.getString(2).split("/");
		anni = c.get(Calendar.YEAR) - Integer.parseInt(dataSplit[2]);
		if ((c.get(Calendar.DAY_OF_MONTH) - Integer.parseInt(dataSplit[0])) < 0) {
			if ((c.get(Calendar.MONTH) - 1 - Integer.parseInt(dataSplit[1])) < 0)
				anni--;
		} else {
			if ((c.get(Calendar.MONTH) - Integer.parseInt(dataSplit[1])) < 0)
				anni--;
		}
		db.close();

		timer = new Timer();
		// timer.schedule(checkPrePlay, 1000, 2000);
		timer.schedule(new TimerTask() {
			@Override
			public void run() {
				runOnUiThread(checkGpsProvider);
			}
		}, 1000, 15000);

		// assegno l'azione da compiere al bottone start/stop/home
		startStop.setOnClickListener(startStopClick);
		startStop.setClickable(false);
	}

	@Override
	protected void onPause() {
		super.onPause();
	}

	@Override
	protected void onResume() {
		doBindService();
		super.onResume();
	}

	@Override
	protected void onDestroy() {
		super.onDestroy();
		doUnbindService();
		stopService(intentServizi);
		timer.cancel();
	}

	/**
	 * variable to start the connection between this activity and the service.
	 */	
	private ServiceConnection connessione = new ServiceConnection() {
		@Override
		public void onServiceConnected(ComponentName className, IBinder service) {
			cronoGpsService = ((Servizi.ServiziBinder) service).getService();
		}

		@Override
		public void onServiceDisconnected(ComponentName className) {
			cronoGpsService = null;
		}
	};

	/**
	 * method to bind activity and service.
	 */
	void doBindService() {
		bindService(new Intent(this, Servizi.class), connessione, this.BIND_AUTO_CREATE);
		System.out.println("doBind called");
		isBound = true;
	}

	/**
	 * method to unbind activity and service.
	 */
	void doUnbindService() {
		if (isBound) {
			unbindService(connessione);
			System.out.println("doUnbind called");
			isBound = false;
		}
	}

	/**
	 * timertask that runs through all the recording process checking avery 15 seconds if the GPS provider is enabled.
	 */
	TimerTask checkGpsProvider = new TimerTask() {
		@Override
		public void run() {
			if (!cronoGpsService.isProviderEnabled() && !alreadyAskedToUser) {
				alreadyAskedToUser = true;
				showGPSDisabledAlertToUser();
			}
			if (!checkPrePlayAlreadyStarted && cronoGpsService.isProviderEnabled()) {
				timer.schedule(new TimerTask() {
					@Override
					public void run() {
						runOnUiThread(checkPrePlay);
					}
				}, 0, 1000);
				checkPrePlayAlreadyStarted = true;
			}
		}
	};

	/**
	 * timertask that when the GPS provider is enabled check the service to know if the first GPS fix has arrived
	 * and then enables the "startStop" button.
	 */
	TimerTask checkPrePlay = new TimerTask() {
		@Override
		public void run() {
			if (!updateDataFromServiceAlreadyStarted) {
				System.out.println("checking gps status..");
				if (cronoGpsService.isProviderEnabled() && cronoGpsService.checkFix()) {
					startStop.setClickable(true);
					startStop.setBackgroundResource(R.drawable.play);
					step = 1;
					System.out.println("GPS signal acquired, ready to start");
					timer.schedule(new TimerTask() {
						@Override
						public void run() {
							runOnUiThread(updateDataFromService);
						}
					}, 1000, 1000);
					updateDataFromServiceAlreadyStarted = true;
				}
			}
		}
	};

	/**
	 * timertask that updates activity data fetching updated data from the service.
	 */
	TimerTask updateDataFromService = new TimerTask() {
		@Override
		public void run() {
			datoVelocitaIst = "" + cronoGpsService.getIstSpeed() + " m/s";
			datoAltitudine = "" + cronoGpsService.getAltitude() + " m";
			datoSatelliti = "" + cronoGpsService.getNumSatellites();
			if (step == REGISTRAZIONE) {
				datoCronometro = cronoGpsService.getTime();
				datoDistanza = cronoGpsService.getDistance() + " m";
				datoCalorie = cronoGpsService.getCalories() + " kcal";
				datoVelocita = cronoGpsService.getMedSpeed() + " km/h";
				if (cronoGpsService.hasLimitBeenReached()) {
					parziale = new Parziale(step);
					daAggiornare.setText(limitiImpostati[numeroAttivita]);
					if (attivitaImpostate[numeroAttivita].equalsIgnoreCase("distanza"))
						daAggiornare.append(" m");
					else if (attivitaImpostate[numeroAttivita].equalsIgnoreCase("calorie"))
						daAggiornare.append(" kcal");
					else
						daAggiornare.append(" min");
					avanzamentoParziale.setProgress(100);
					
					if (numeroAttivita >= (attivitaImpostate.length - 1)) {
						step++;
					} else {
						// passo ad un indice attività / limite successivo
						numeroAttivita++;
						System.out.println("numeroAtt = " + numeroAttivita + " su " + attivitaImpostate.length);
						// aggiorno i limiti con cui il servizio dovrà procedere
						// la registrazione
						attivitaDaPassareAServizio = attivitaImpostate[numeroAttivita];
						if (attivitaDaPassareAServizio.equalsIgnoreCase("distanza")) {

							limiteDaPassareAServizio = parziale.getDist() + Integer.parseInt(limitiImpostati[numeroAttivita]);
							System.out.println("nuovo limite distanza : " + limiteDaPassareAServizio);
						} else if (attivitaDaPassareAServizio.equalsIgnoreCase("calorie")) {

							limiteDaPassareAServizio = parziale.getCal() + Integer.parseInt(limitiImpostati[numeroAttivita]);
							System.out.println("nuovo limite calorie : " + limiteDaPassareAServizio);
						} else {

							limiteDaPassareAServizio = parziale.getCrono() + Integer.parseInt(limitiImpostati[numeroAttivita]) * 60;
							System.out.println("nuovo limite ora : " + limiteDaPassareAServizio);
						}
						// creo le textview che mostreranno le attività corrente
						// e il relativo avanzamento
						TextView newAttTextView = new TextView(getApplicationContext());
						newAttTextView.setText(attivitaDaPassareAServizio);
						TextView newLimTextView = new TextView(getApplicationContext());
						newAttTextView.requestFocus();
						limiteAggiornato = "0 / " + limitiImpostati[0] + " ";
						if (attivitaImpostate[0].equalsIgnoreCase("distanza"))
							limiteAggiornato += "m";
						else if (attivitaImpostate[0].equalsIgnoreCase("calorie"))
							limiteAggiornato += "kcal";
						else
							limiteAggiornato += "min";
						newLimTextView.setText(limiteAggiornato);
						// aggiungo le textView ai due layout nella scrollView
						cassettoAttivita.addView(newAttTextView);
						cassettoLimiti.addView(newLimTextView);

						// aggiorno il limite da raggiungere nel servizio
						cronoGpsService.setLimitReached(false);
						cronoGpsService.enableWarning();
						System.out.println("nuovo tipo " + attivitaDaPassareAServizio);
						cronoGpsService.setTrainingParameters(attivitaDaPassareAServizio, limiteDaPassareAServizio);
					}
				}
			}
			checkNumSatellites();
			AggiornaDatiUi();
			if (step == FINE) {
				step++;
				System.out.println("***Service is going to be killed");
				doUnbindService();
				getApplicationContext().stopService(intentServizi);
				if (!alreadySavedDb) {
					startStop.setBackgroundResource(R.drawable.home);
					db = op.getWritableDatabase();
					ContentValues values = new ContentValues();
					values.put(op.NOME, nome);
					// data e ora di inizio registrazione
					if (inizioAttivita.getMinutes() < 10) {
						values.put(op.DATAEORA, "" + inizioAttivita.getDate() + "/" + (inizioAttivita.getMonth() + 1) + "/"
								+ (inizioAttivita.getYear() + 1900) + "-" + inizioAttivita.getHours() + ":0" + inizioAttivita.getMinutes());
					} else
						values.put(op.DATAEORA, "" + inizioAttivita.getDate() + "/" + (inizioAttivita.getMonth() + 1) + "/"
								+ (inizioAttivita.getYear() + 1900) + "-" + inizioAttivita.getHours() + ":" + inizioAttivita.getMinutes());
					// tipo allenamento
					values.put(op.TIPO, tipoAttivita);
					// distanza percorsa
					values.put(op.DISTANZA, datoDistanza);
					// tempo totale
					values.put(op.DURATA, datoCronometro);
					// calorie consumate
					values.put(op.CALORIE, datoCalorie);
					// velocità media
					values.put(op.VELOCITA, datoVelocita);
					// inserisco i dati nel DB
					db.insertOrThrow(op.TABLE2, null, values);
					db.close();
					alreadySavedDb = true;
				}
			}
		}
	};

	/**
	 * method that updates the UI every time it is called.
	 */
	private void AggiornaDatiUi() {
		velocitaist.setText(datoVelocitaIst);
		altitudine.setText(datoAltitudine);
		if (hasNumSatellites)
			satelliti.setText(datoSatelliti);
		else if (!hasNumSatellites)
			satelliti.setText("Non Disponibile");
		else
			satelliti.setText("0");
		if (step == REGISTRAZIONE) {
			daAggiornare = (TextView) cassettoLimiti.getChildAt(numeroAttivita);
			if (attivitaDaPassareAServizio.equalsIgnoreCase("distanza")) {
				parzialeLimite = Integer.parseInt(cronoGpsService.getDistance()) - parziale.getDist();
				limiteAggiornato = "" + parzialeLimite + " / " + limitiImpostati[numeroAttivita] + " m";
				daAggiornare.setText(limiteAggiornato);
				avanzamentoParziale.setProgress((int) ((100 * parzialeLimite) / (Integer.parseInt(limitiImpostati[numeroAttivita]))));
			} else if (attivitaDaPassareAServizio.equalsIgnoreCase("calorie")) {
				parzialeLimite = (int) Double.parseDouble(cronoGpsService.getCalories()) - parziale.getCal();
				limiteAggiornato = "" + parzialeLimite + " / " + limitiImpostati[numeroAttivita] + " kcal";
				daAggiornare.setText(limiteAggiornato);
				avanzamentoParziale.setProgress((int) ((100 * parzialeLimite) / (Integer.parseInt(limitiImpostati[numeroAttivita]))));
			} else {
				parzialeLimite = cronoGpsService.getTotSec() - parziale.getCrono();
				avanzamentoParziale.setProgress((int) ((100 * parzialeLimite) / (Integer.parseInt(limitiImpostati[numeroAttivita]) * 60)));
				String orologio = "";
				if ((parzialeLimite / 3600) > 1) {
					orologio += parzialeLimite / 3600 + ":";
					parzialeLimite = parzialeLimite % 3600;
				}
				if ((parzialeLimite / 60) < 10)
					orologio += "0" + parzialeLimite / 60;
				else
					orologio += ":" + parzialeLimite / 60;
				parzialeLimite = parzialeLimite % 60;
				if (parzialeLimite < 10)
					orologio += ":0" + parzialeLimite;
				else
					orologio += ":" + parzialeLimite;
				limiteAggiornato = "" + orologio + " / " + limitiImpostati[numeroAttivita] + " min";
				daAggiornare.setText(limiteAggiornato);
			}
		}
	}

	/**
	 * method to display an alertdialog asking user to enable GPS provider.
	 */
	private void showGPSDisabledAlertToUser() {
		AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
		alertDialogBuilder.setMessage("Il GPS è disabilitato, per il corretto funzionamento dell'applicazione dev'essere abilitato, vuoi abilitarlo? ")
				.setCancelable(false).setPositiveButton("Vai alle Impostazioni", new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int id) {
						Intent callGPSSettingIntent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
						startActivity(callGPSSettingIntent);
						alreadyAskedToUser = false;
						dialog.cancel();
					}
				});
		alertDialogBuilder.setNegativeButton("Annulla", new DialogInterface.OnClickListener() {
			public void onClick(DialogInterface dialog, int id) {
				alreadyAskedToUser = false;
				doUnbindService();
				getApplicationContext().stopService(intentServizi);
				SelezioneAttivita.daTerminare = true;
				finish();
				dialog.cancel();
			}
		});
		AlertDialog alertGpsDisabled = alertDialogBuilder.create();
		alertGpsDisabled.show();
	}

	/**
	 * method to check if GPS proider can provide the number of satellites used for each location fix.
	 */
	private void checkNumSatellites() {
		if (cronoGpsService.getNumSatellites() != 0)
			hasNumSatellites = true;
		else
			hasNumSatellites = false;
	}

	/**
	 * onclicklistener of the button startStop
	 */
	private OnClickListener startStopClick = new OnClickListener() {
		@Override
		public void onClick(View v) {
			// partenza cronometro allo start
			if (step == PRONTO) {
				cronoGpsService.setProfileData(isMale, anni, altezza, peso);
				if (attivitaDaPassareAServizio.equalsIgnoreCase("tempo"))
					limiteDaPassareAServizio = limiteDaPassareAServizio * 60;
				cronoGpsService.setTrainingParameters(attivitaDaPassareAServizio, limiteDaPassareAServizio);
				getApplicationContext().startService(intentServizi);
				inizioAttivita = c.getTime();
				startStop.setBackgroundResource(R.drawable.stop);
				step = 2;
				System.out.println("Receiving updates");
			}
			// stop aggiornamenti e cronometro quando premo stop
			else if (step == REGISTRAZIONE) {
				System.out.println("Service is going to be killed");
				doUnbindService();
				getApplicationContext().stopService(intentServizi);
				startStop.setBackgroundResource(R.drawable.home);
				step = 3;
				// apro database e inserisco i dati della corsa
				db = op.getWritableDatabase();
				ContentValues values = new ContentValues();
				values.put(op.NOME, nome);
				System.out.println("nome " + nome);
				// data e ora di inizio registrazione
				if (inizioAttivita.getMinutes() < 10) {
					values.put(op.DATAEORA, "" + inizioAttivita.getDate() + "/" + (inizioAttivita.getMonth() + 1) + "/"
							+ (inizioAttivita.getYear() + 1900) + "-" + inizioAttivita.getHours() + ":0" + inizioAttivita.getMinutes());
				} else
					values.put(op.DATAEORA, "" + inizioAttivita.getDate() + "/" + (inizioAttivita.getMonth() + 1) + "/"
							+ (inizioAttivita.getYear() + 1900) + "-" + inizioAttivita.getHours() + ":" + inizioAttivita.getMinutes());
				// tipo allenamento
				values.put(op.TIPO, tipoAttivita);
				System.out.println("TIPO " + tipoAttivita);
				// tempo totale
				values.put(op.DURATA, datoCronometro);
				System.out.println("DURATA " + datoCronometro);
				// distanza percorsa
				values.put(op.DISTANZA, datoDistanza);
				System.out.println("DISTANZA " + datoDistanza);
				// calorie consumate
				values.put(op.CALORIE, datoCalorie);
				System.out.println("CALORIE " + datoCalorie);
				// velocità media
				values.put(op.VELOCITA, datoVelocita);
				System.out.println("VELOCITA " + datoVelocita);
				// inserisco i dati nel DB
				db.insertOrThrow(op.TABLE2, null, values);
				db.close();
				alreadySavedDb = true;
			} else if (step >= FINE) {
				SelezioneAttivita.daTerminare = true;
				finish();
			}
		}
	};

	private class Parziale {

		String datoCrono;
		String datoDist;
		String datoCal;

		private Parziale(int passo) {
			if (passo == PREPARAZIONE) {
				datoCrono = "" + 0;
				datoDist = "" + 0;
				datoCal = "" + 0;
			} else {
				datoCrono = "" + cronoGpsService.getTotSec();
				datoDist = cronoGpsService.getDistance();
				datoCal = cronoGpsService.getCalories();
				System.out.println("crono " + datoCrono + " dist " + datoDist + " kcal " + datoCal);
			}
		}

		private int getCrono() {
			return Integer.parseInt(datoCrono);
		}

		private int getDist() {
			return Integer.parseInt(datoDist);
		}

		private int getCal() {
			return Integer.parseInt(datoCal);
		}
	}
}
